EnigmA Amiga Run 1995 November

home *** CD-ROM | disk | FTP | other *** search

/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / util / misc / zxam16b.lha / ZXAM Spectrum / ZXAM_Spectrum.DOCesp < prev next >

Wrap

Text File | 1995-01-27 | 69KB | 1,482 lines

[0m[0 p [0;1;33;40mZXAM SPECTRUM EMULATOR v1.6b[0m © 1993-95 WareSoft Todos los derechos reservados Programado por Antonio J. Pomar Rosselló [0;1mDISTRIBUCION[0m Este programa es SHAREWARE. Esto sigifica que tienes un mes de tiempo para probarlo, y si te gusta deberías mandar 15 US$ (unas 2000 pts) al autor. A cambio recibirás la última versión disponible (probablemente la versión 128k estará disponible para marzo de 1995). Con esta contribución estás asegurando el desarrollo y mejora posterior del emulador. Gracias por adelantado. Esta versión SHAREWARE puede circular libremente siempre que se incluyan todos los ficheros asociados al programa. Está prohibido utilizar el programa para fines comerciales, o sea que solo se pueden cargar los gastos normales de copia y envio que se cargan habitualmente en las librerias de Dominio Público. También puedes meterlo en BBS o incluirlo en discos de revista. El paquete completo de distribución comprende: ZXAM_SpectrumAGA Este es el programa ejecutable (con icono). ZXAM_SpectrumAGA_FASTER El mismo, pero versión rápida (con icono). ZXAM_SpectrumOCS_ECS Versión para OCS/ECS (con icono). ZXAM_SpectrumOCS_ECS_FAST Versión rápida para ECS/OCS (con icono). ZXAM_Spectrum.DOCesp El texto que lees ahora (con icono). ZXAM_Spectrum.DOCeng Traducción a inglés de este DOC (con icono). LEEME!! Notas de distribución (con icono). README!! Lo mismo, pero en inglés (con icono). INTERFACE.IFF Esquema del interface de cinta (con icono). DIGIT_INTERFACE.IFF Digitalización de mi interface (con icono). powerpacker.library Necesaria para cargar ficheros comprimidos. El autor del programa no acepta ninguna responsabilidad sobre cualquier perjuicio que puede suponer el uso o abuso del programa, ni ofrece ninguna garantia sobre el programa y sus capacidades. Tampoco se garantiza nada sobre la precisión o estilo literario de este documento ni se acepta ninguna responsabilidad sobre las consecuencias que puede acarrear su lectura. Tampoco acepta ninguna responsabilidad sobre cualquier consecuencia que puede tener la realización o uso del interface de cassette. Esta prohibido montar y vender el interface para sacar un provecho económico. Se reconocen todas las marcas registradas, marcas comerciales y Copyrights de los productos mencionados en este documento. Por lo que he podido leer en el DOC del Spectrum Emulator v1.7 la casa AMSTRAD, que posee ahora los derechos sobre los componentes del Spectrum, ha dado permiso especial a los autores de emuladores para poder distribuir la ROM del Spectrum original. De todas formas el Copyright sobre la ROM sigue siendo de AMSTRAD. La pantalla KeysHelp.iff ha sido incluida con el permiso del autor (Mikael Ostergren) para ayudar a localizar teclas en el spectrum 48k. La powerpacker.library es © Nico François. El Sinclair ZX Spectrum Emulator es © Peter McGavin. El Sinclair ZX Spectrum Emulator "Z80" es © Gerton Lunter. El emulador ZX Spectrum (SPEC386) es © Pedro Gimeno. [0;1mREQUERIMIENTOS[0m Este programa necesita WorkBench 3.0 (o sea, versión 39), los chips gráficos AGA y un microprocesador 68020, o versiones superiores (en el caso de la versión OCS/ECS se necesita solo 68020 y WB 2.04 o superiores). En resumen, necesita un Amiga 1200 como mínimo. Además necesita la powerpacker.library en libs: o en el mismo directorio del programa. Por otro lado, para los requesters de ficheros se usa la libreria standard del sistema 'asl.library'. Esta libreria tiene el problema de releer el directorio cada vez que abre el requester, con lo que puede ser desesperante cargar ficheros desde disquete, o cuando en el disco duro hay muchos ficheros (como en mi caso, que son 400). Para evitar esto lo mejor seria usar la reqtools.library, ya que su requester tiene un buffer que evita tener que leer el directorio cada vez, pero debido a graves problemas técnicos aún no he podido implementarlo. Mientras tanto la mejor opción es usar el programa RTPatch, de Nico François, que parchea las librerias asl/req/arp para que usen el requester de la reqtools. Así, además, todos los demás programas que usen asl/req/arp usarán dicho requester, que es mucho mejor que los originales. Curiosamente con RTPatch 1.3 (que es el parche que yo uso) el buffer funciona perfectamente, pero con el ReqChange 3.0 (otro parche que se supone hace lo mismo) el buffer no funciona. ¿Que tiene de AGA el emulador?: Pues usa algunas de las nuevas posibilidades específicas de los chips AGA para la conversión de pixels y colores de la pantalla del Spectrum, para adaptarla a los bitplanos del Amiga. Como verás, ya hay incluida con el paquete una versión OCS/ECS del emulador. Esta versión necesita 68020+ y WorkBench 2.04+. Los chips gráficos pueden ser OCS/ECS/AGA indistintamente. Esta versión es de prueba. Si hay algún problema, no dudes en comunicármelo (yo no puedo probarla completamente por que no dispongo de ningún ordenador OCS/ECS con 68020+). La versión OCS/ECS usa un sistema de conversión de pantalla más lento que la versión AGA (se nota sobre todo en juegos como el Uridium). Aún así, en muchos casos la diferencia no es apreciable. Las únicas cosas que posee el AGA y el OCS/ECS no, es la posibilidad de funcionar en monocromo/color y el FLASH de colores (substituido por un INVERSE). Algo muy importante es la memoria FAST de 32 bits. El emulador funciona bién sobre memoria CHIP, pero si hay memoria FAST 32 bits disponible el incremento de velocidad puede ser impresionante. Por lo que yo he podido saber la adición de FAST al Amiga 1200 incrementa la velocidad de proceso al 219% (más del doble). Esto se debe a la constante lucha entre el procesador y los chips gráficos para acceder a la memoria CHIP, y al sistema de SLOTs que usan los chips gráficos para asignar el tiempo de uso de la memoria CHIP entre éstos y el procesador. Debido al sistema de SLOTs un Amiga 4000/030 sin FAST solo va un 15% mas rápido que un Amiga 1200 sin FAST. Por otro lado la velocidad del emulador depende mucho del programa de Spectrum que se esté ejecutando. [0;1mINTRODUCCION[0m Como habrás deducido de forma inmediata este programa tiene como función principal (y única) la de emular un Sinclair ZX Spectrum 48k, con sus entrañables atributos y su sonido de 1 bit (lagrimilla...). Notarás que el emulador está en inglés, pero cualquiera que haya usado un Spectrum antes sabrá lo que significa LOAD, SAVE, POKE, etc... [0;1mFORMATOS DE PROGRAMA[0m Antes de poder comprender la función de algunos de los gadgets y ToolTypes del programa debemos discutir algo sobre formatos de programas de Spectrum. Actualmente hay varios emuladores de Spectrum 48k para diferentes ordenadores (Amiga, PC, Atari, etc...) y cada uno de estos emuladores graba los programas en disco en un formato de fichero diferente. Esto significa que para poder usar programas grabados con un emulador en otro debes disponer de algún tipo de utilidad que convierta los programas de un formato a otro (yo hice uno en BASIC compilado para pasar programas Spectrum de PC a Amiga). Este emulador intenta evitar la necesidad de conversor admitiendo cargar y grabar directamente varios formatos en vez de tener un solo formato propio. Asi también se puede usar el emulador como conversor de formatos, si surge la necesidad. De momento hay implementados cuatro formatos (los únicos que conozco) a los que he llamado provisionalmente PC, MIRAGE, Z80 y KGB, y que son: PC: Este formato proviene del emulador de Spectrum para PC programado por Pedro Gimeno. El ejecutable se llama SPEC386.EXE y la versión que he usado (yo no tengo PC) es la 0.99D ß. Supongo que a estas alturas debe haber una versión mas completa en circulación (creo recordar que este emulador ya tiene unos años). Necesita un 386DX a 25MHz con un caché de 256Kb para acercarse a la velocidad del Spectrum real. Estos ficheros se reconocen por que ocupan 49190 bytes en el disco y suelen llevar la extensión .SP al final del nombre. MIRAGE: Este es el formato del Spectrum Emulator 1.7 de Peter McGavin. Es un emulador para AMIGAs sin chips AGA. Los ficheros se reconocen por que ocupan 49179 bytes y suelen llevar la extensión .snapshot, aunque yo prefiero cambiarsela por .mirage para evitar confusiones, ya que son muchos los emuladores que usan esa extensión. Hay que notar que hasta la versión 1.6 del Spectrum Emulator este formato no guardaba el color actual del borde, por lo que al cargar ficheros de formato pre-1.6 el borde arrancará en negro. Para arreglar esto puedes regrabar en dicho formato, ya que el ZXAM utiliza el formato moderno, que almacena el borde correctamente. Este formato también lo usan los emuladores (para PC) VGASPEC (*.SNA, no sé el autor) y JPP (*.SP, de Arnt Gulbrandsen). Z80: este formato (implementado a partir de la versión 1.6) es el que usa el emulador de Spectrum (para PC) 'Z80' de G.A.Lunter. El emulador admite la carga de ficheros .Z80 de formato antiguo (versión 1.45 del Z80) y moderno (versión 2.01 del Z80), siempre que sea un fichero de Spectrum 48k. En caso de que sea 128k o necesite de la emulación de interface I o cualquier otro hardware no soportado por el ZXAM, el fichero será rechazado como desconocido. Este formato solo está disponible para cargar, pero no para grabar. KGB: este fomato (implementado también a partir de la versión 1.6b) es el del viejo emulador KGB para Amiga. Se puede reconocer por que el tamaño es siempre 49486 bytes. No se quien es el autor de dicho emulador (la versión que yo tengo no incluye DOC ni nada parecido) ni si aún se usa debido a que es incompatible con la versión 2.0 y superiores del sistema operativo. Este fomato está disponible solo para cargar. En todos los casos el emulador admite que los programas estén comprimidos con powerpacker. Hay que notar que el emulador no usa NUNCA la extensión del nombre del fichero para identificar su formato. En vez de eso se hacen una serie de comprobaciones en la estructura del fichero para reconocerlo. Si quieres poner otra extensión a un fichero, puedes hacerlo sin que ello afecte la posibilidad de cargarlo en el emulador. Eso si, tienes que añadir esa extensión a la plantilla (tooltype PATTERN en el icono del emulador) del requester de ficheros, ya que si no esos ficheros no aparecerán el él. Además de estos formatos hay otro, el llamado .TAP, que no es un snapshot en si mismo si no que es una serie de cabeceras y bloques de datos unidos en un solo fichero. Junto al emulador hay un script ARexx que puedes usar para descomponer un fichero .TAP en la serie del .header y .bytes que contiene, y poder cargar así dichos bloques con la opción de LOAD desde disco. En caso de que tengas información sobre otros formatos de otros emuladores, aunque sean de otros ordenadores, solo tienes que mandarme un disco con varios programas en ese formato y la información de que dispones. Procuraré incluir en la proxima versión del emulador la posibilidad de usar dicho formato. Es MUY importante que me mandes algún programa grabado en ese formato, si no no podré probar la carga en dicho formato. [0;1mARRANQUE DEL PROGRAMA[0m El programa está pensado para arrancar desde WorkBench ya que las opciones se leen del icono del programa. De todas formas, si lo arrancas desde el SHELL el programa buscará el icono en el mismo directorio del ejecutable, para cargar dichas opciones. Además, se "despegará" de la ventana del SHELL. Si hay algún problema al arrancar el programa, éste lo comunicará con un requester y volverá al sistema operativo. Las ToolTypes ("Tipos Herramientas" en WB3.0 en castellano) que se pueden meter en el icono son: PATTERN= Le indicamos el pattern (plantilla) para el requester de ficheros. Este pattern es un filtro que especifica que ficheros deben mostrarse en dicho requester. Consulta el manual del ordenador sobre el uso de plantillas de fichero. LOADPATH= Indica en que directorio queremos que se abra inicialmente el requester de cargar. Esto es útil para dirigirlo al directorio del disco duro donde guardas normalmente los programas de Spectrum y no tener que meter cada vez el path (yo tengo en el disco duro un directorio con 232 juegos comprimidos [4.7 Megas]). SAVEPATH= Indica en que directorio queremos que se abra inicialmente el requester de grabar. DEFFORMAT= Indica el formato por defecto usado para grabar los programas de Spectrum (formato PC, MIRAGE, PC_PP y MIRAGE_PP). De todas formas se puede cambiar el formato usado mediante los gadgets adecuados de la ventana de control. REXXPATH= Indicamos el directorio donde se debe abrir el requester para seleccionar scripts ARexx. El nombre de los scripts debe acabar en '.zxam'. ROMFILE= Indicamos la ROM a cargar, substituyendo la interna del emulador (la original del Spectrum 48k). La ROM puede estar comprimida con powerpacker. CUIDADO con las ROM extrañas por que pueden provocar incompatibilidades con algunos juegos (no es culpa mia ;-) PRERUN= Fija una linea de comandos AmigaDOS para ejecutar justo antes de arrancar la emulación. Por ejemplo, con "PRERUN=cpu nocache noburst" se desactivarian los cachés y el burst del procesador. Antes de ejecutar la linea PRERUN el emulador guarda el estado de los cachés y los restaura al volver de la emulación (con la tecla HELP), justo antes de ejecutar la linea POSTRUN. De esta forma se puede poner un comando que desactive los cachés en el momento de emular sin que en el WorkBench tengamos que tener los cachés desactivados. POSTRUN= Fija una linea de comandos a ejecutar justo al salir de la emulación (con la tecla HELP). LOADMODE= Fija el modo de la rutina LOAD de la ROM (TAPE o DISK). SAVEMODE= Fija el modo de la rutina SAVE de la ROM (TAPE, DISK o DISK_PP para que se compriman los datos al grabar. [0;1mVENTANA DEL PROGRAMA[0m Si has arrancado el programa verás que abre una ventana en el WorkBench con los gadgets de cargar, grabar, poke, etc. Los gadgets que tienen una letra subrayada (TODOS) significa que si pulsas la tecla correpondiente a dicha letra es como si pulsaras el gadget con el ratón. Las funciones de los gadgets son las siguientes: Load Program .- Abre el requester de ficheros para que puedas seleccionar el programa que quieres cargar. El emulador detectará automáticamente en que formato está el programa, por lo que no es necesario especificarle nada. IMPORTANTE: los programas de Spectrum se pueden comprimir con el programa PowerPacker, y se descomprimirán al cargarlos. Así nos ahorramos un montón de espacio en disco (en un disco de 880k suelen caber unos 45 programas una vez comprimidos). Una vez cargado se verá el nombre del fichero en el recuadro "Loaded File" y el formato en que está en el recuadro "Format". Si intentas cargar un fichero que no es un programa de Spectrum lo único que puede pasar es que se borre el contenido anterior de la memoria del Spectrum. Hay que notar que el emulador YA es capaz de cargar programas directamente desde cinta (V1.3 ß), pero debes montar el interface descrito en la pantalla INTERFACE.IFF. A partir de la versión 1.5 la ventana del emulador es una AppWindow, o sea, puedes tirar dentro los iconos de los ficheros a cargar. Si lo que metes es un cajón o un disco, se abrirá el requester de ficheros en dicho cajón/disco. Reload.- Vuelve a cargar de disco el programa de Spectrum que aparece en la ventana "Loaded File", sin abrir el requester de ficheros. Save program.- Graba la memoria del Spectrum en el formato indicado por los gadgets de la derecha (recuadro "SAVE FORMAT"). POKE.- Es facil imaginarselo, ¿no?. Recuadro "Save Format".- En este recuadro hay 4 gadgets que determinan el formato en el que se grabará la memoria del Spectrum si seleccionamos el gadget "Save Program". Los formatos son MIRAGE y PC, y sus versiones comprimidas con powerpacker, MIRAGE_PP y PC_PP. RUN.- Arranca el Spectrum. En el momento de arrancar se desactiva la multitarea y el emulador toma el control de la máquina. He preferido desactivar la multitarea por que no me parece necesaria en el momento de usar un Spectrum y para que el emulador tenga aspecto de Spectrum de verdad. Más adelante se explica como volver al WorkBench. Reset & RUN.- Lo mismo que RUN pero forzando un RESET del Spectrum. Run ARexx.- Abre un requester de ficheros para elegir el script ARexx a ejecutar. Se abrirá en el path fijado por la ToolType REXXPATH. Solo se mostrarán los ficheros con la extensión '.zxam'. Abort ARexx.- Es un gadget que está totalmente bajo el control del script en cuanto a activarlo/desactivarlo y leerlo periodicamente. El emulador simplemente informa al script de que ha sido pulsado y es éste el que debe decidir lo que debe hacer. [0;1mMENUS Y TECLADO[0m Todos los gadgets que tienen una letra subrayada significa que pulsando la tecla correspondiente a esa letra es como si pulsáramos el gadget, sin necesidad de tocar el ratón para nada. También tenemos la tecla HELP, que mostrará el requester de 'About...', la tecla ESCAPE, con la que salimos del programa, y la tecla TAB, que selecciona el primer gadget numérico de la ventana para poder modificarlo sin tener que seleccionarlo con el ratón. Mientras estás modificando un gadget numérico puedes pulsar TAB para pasar al siguiente gadget numérico, o Shift+TAB para pasar al anterior. Por otro lado está el menú del programa, aunque todo lo que está en el menú se puede hacer desde teclado o pulsando los gadgets adecuados. Esta ahí por si se quisiera usar el programa sin el teclado, ya que la opcion 'About...' no tiene gadget asociado en la pantalla (es una función importante...). A partir de la versión 1.6 se ha añadido el menu "Options" en el que se puede seleccionar hacia donde desviar los comandos LOAD y SAVE de la ROM del Spectrum, para poder grabar ficheros de datos del BASIC, o cargar fases en los juegos multicarga, directamente del disco. La opción Disk Crunched significa que al grabar los datos será comprimidos automáticamente con la powerpacker.library. [0;1mTECLADO EN EL SPECTRUM[0m Cuando el Spectrum está en marcha el teclado equivale al de un Spectrum 48k, aunque he configurado algunas teclas especiales: <- Borra un caracter (Shift+0) Ctrl Equivale a pulsar Caps+Symbol, o sea, pasa a modo E (extendido) Alt Equivale a Symbol Shift Del Equivale a Shift+1 (Edit) Help Vuelve al WorkBench Esc Reset F1 Conmuta entre modo color o blanco y negro. En ordenadores sin memoria FAST el conflicto existente entre el procesador y los chips AGA para acceder a la memoria CHIP frena el procesador. Si necesitas el máximo de velocidad puedes poner el emulador en blanco y negro, con lo que se acelerará un 10%, aproximadamente. Además el sonido irá MUCHO mejor. F2 En modo Blanco y Negro invierte la imagen. F6 Arranca el transfer (el programa se graba en cinta listo para ser cargado en un Spectrum real o en el propio emulador). Cursores Equivalen a los cursores del Spectrum original (Shift+5 6 7 8). , (tecla a la derecha de la M) equivale a la coma (Symbol+N) . (2ª tecla a la derecha de la M) equivale al punto (Symbol+M) ´ (3ª tecla a la derecha de la M) equivale a las comillas (Symbol+P) Ñ (tecla a la derecha de la L) equivale a dos puntos (Symbol+Z) ; (2ª tecla a la derecha de la L) equivale al punto y coma (Symbol+O) El keypad funciona completo. El joystick Kempston se emula con el de Amiga. Debo decir que seguramente más de un usuario de Amiga 1200 notará algo extraño en el teclado, y es que no se pueden pulsar al mismo tiempo 2 teclas en la misma linea. Esto significa que si pulsas, por ejemplo, la P y la Q al mismo tiempo el emulador creerá que no tienes pulsada ninguna tecla. Este comportamiento no se debe a un fallo en el emulador si no a una "curiosidad" bastante molesta del teclado del Amiga 1200 (al menos del alemán, que es el que yo tengo). [0;1mEMULACION[0m Detalles puntuales de la versión completa (FULL): - La ROM del Spectrum 48k original está en el ejecutable, en vez de venir en un fichero separado, por comodidad. - El registro R es correctamente emulado. - En el registro F no se emulan los 2 bits no utilizados, y se emulan parcialmente los bit N y H. - La emulación del BCD es prácticamente completa. - Se emulan todas las instrucciones "secretas" del Z80. - El modo 0 de interrupciones se emula como el modo 1 (RST $38). - No hay NMI (¿para que lo quiero?). - El borde es de tipo lento, debido a que está implementado en la copperlist. Esto significa que, de momento, no se vén las rayas al hacer SAVE a cinta, pero el comando BORDER funciona correctamente. - Las instrucciones de transferencia funcionan a nivel 32 bits. - Se puede conmutar (con F1) en modo blanco y negro o color para acelerar el emulador en ordenadores sin memoria FAST. - FLASH perfectamente emulado. - El sonido se emula a nivel de la instrucción OUT. Se emulan los 2 bits del spectrum (el del altavoz y el de cassette) en un solo canal del Amiga. - El joystick Kempston se emula a nivel de la instrucción IN. - La sincronización con el barrido de la pantalla es solo parcial. Por eso algunos programas parpadearán (de momento). - La pantalla del Spectrum se abre en PAL con 15KHz de barrido horizontal, o sea que no se puede usar el emulador con monitores tipo VGA, aunque si se puede usar con monitores MultiSync, con el Commodore 1084, el Philips 8833 y con cualquier televisor. No hay parches que valgan. - La pantalla es compatible genlock. - El emulador funciona correctamente aunque VBR no sea 0. >>>>>>>>> Añadido para 1.3 ß <<<<<<<<< - Carga de cinta, por parche (en realidad parchecillo) en la ROM. - Graba hacia cinta en TIEMPO REAL, o sea, es la emulación Z80 la que manda los impulsos a la salida de audio. Incluso en 1200 sin memoria FAST. - El borde es "casi" real (ya no es de tipo lento). >>>>>>>>> Añadido para 1.3b ß <<<<<<<<< - El emulador incorpora un transfer a cinta, para pasar a cinta los programas que tengas en disco. >>>>>>>>> Añadido para 1.6 <<<<<<<<< - Se puede desviar las rutinas LOAD y SAVE de la ROM para que carguen o graben sobre disco. Notas sobre versión FAST (v1.3 ß): - No emula BCD. Esto significa que el BASIC no imprimirá correctamente los numeros, y que algunos juegos no imprimirán bién la puntuación. - Las temporizaciones son menos precisas, lo que puede suponer que algunos juegos se comporten de una forma "peculiar". - No se emula el registro R. - La salida de audio no está estabilizada, por lo que el SAVE a cinta no funciona. - El borde es de tipo lento. - No hay LOAD de cinta. (en realidad la versión FAST es solo PARA JUGAR!!) - La diferencia de velocidad entre la versión FULL y la FAST es de entre un 5% y un 10% (depende del juego). La verdad es que prefiero usar la versión FULL en mi 1200 para tener la emulación lo más completa posible. [0;1mPUERTO AREXX[0m A partir de la versión 1.4 ß el emulador tiene un puerto ARexx. Este puerto es ideal para crear scripts que permitan soportar nuevos formatos, ensamblar, desensamblar, hacer pokeadores, y cualquier cosa que se te ocurra. El puerto tiene el nombre 'ZXAM_REXX', aunque solo usarás el nombre para comprobar si el emulador está presente, como verás más abajo. Junto con el emulador encontrarás scripts de ejemplo para cargar formatos de snapshot, para grabar la pantalla del Spectrum como IFF, para conversión de formatos en bloque, para listar el programa BASIC que pueda haber en la memoria del Spectrum, para sacar la ROM del Spectrum del emulador, por si quieres modificarla por alguna razón, para desensamblar la memoria del spectrum y para descomponer ficheros .TAP. La mayoria de estos scripts son simples ejemplos de uso de las funciones que incorpora el ZXAM. Una muestra de las posibilidades del puerto ARexx es el script Monitor.zxam (hecho por Leonardo Cocaña Galán), que es un simple desensamblador que te permite 'hurgar' por las tripas del Spectrum. Es solo un principio, que mejorandolo puede llegar a ser un completo desensamblador/monitor de C/M. Algunos de los scripts usan algunos comandos del sistema operativo (como requestchoice o multiview). Es caso de no disponer de estos, deberás modificar los scripts para que usen los que tengas. El puerto ARexx del emulador tiene una peculiaridad, y es que es un Function Host, no un Command Host. Traducido al 'cristiano' significa que lo que tiene el emulador no son comandos, sino funciones. De esta forma no es necesario hacer ADDRESS ZXAM_REXX o OPTIONS RESULTS al principio de los scripts. Además, así se pueden usar las funciones directamente dentro de expresiones. La única regla es que los parámetros se entregan entre paréntesis, y que las funciones sin parámetros necesitan un paréntesis vacio tras ellas. Además, al ser un function host, todas las funciones del emulador empiezan por ZXAM, para evitar conflictos con nombres de funciones de otros host o librerias. Los nombres son independientes de mayúculas/minúsculas. Las funciones sin parámetros se pueden ejecutar como comandos (ADDRESS...). Las 56 funciones implementadas en la versión 1.6b (39.21) son: ZXAMGetReg: Toma el valor de un registro del Z80 de 8 o 16 bits. Mirar sección 'Registros' para los registros soportados. El parámetro opcional 'formato' fija el formato en que debe darse el valor devuelto ('h' para hexadecimal y 'd' para decimal). El formato por defecto es decimal. formato: valor = ZXAMGetReg( nombre registro , [formato] ) ------------------------------------------------------------------------------- ZXAMSetReg: Mete un valor de 8 o 16 bits en un registro del Z80. Mirar sección 'Registros' para más detalles. formato: ZXAMSetReg( nombre registro , valor ) ------------------------------------------------------------------------------- ZXAMPeek: Lee un byte de la dirección dada de la memoria del Spectrum. formato: valor = ZXAMPeek( direccion spectrum ) ------------------------------------------------------------------------------- ZXAMPoke: Escribe un byte en la memoria del Spectrum. formato: ZXAMPoke( direccion spectrum , valor 8 bits ) ------------------------------------------------------------------------------- ZXAMDPeek: Lee un valor de 16 bits de la memoria del Spectrum en formato Z80, o sea, el byte menos significativo está primero. formato: valor = ZXAMDPeek( direccion spectrum ) ------------------------------------------------------------------------------- ZXAMDpoke: Escribe un valor de 16 bits en la memoria del Spectrum. Lo escribe en formato Z80, o sea, el byte menos significativo se coloca primero. formato: ZXAMDPoke( direccion spectrum , valor 16 bits ) ------------------------------------------------------------------------------- ZXAMGetMem: Lee un trozo de memoria de la dirección y el tamaño dados y lo entrega como cadena. formato: cadena = ZXAMGetMem( direccion spectrum , tamaño ) ------------------------------------------------------------------------------- ZXAMPutMem: Coloca la cadena dada en la dirección especificada de la memoria de Spectrum. La cadena suele ser una secuencia de bytes, no un texto. formato: ZXAMPutMem( direccion spectrum , cadena ) ------------------------------------------------------------------------------- ZXAMFindByte: Busca el byte a partir de la dirección dada. Si llega al tope superior de la memoria del Spectrum sin encontrarlo, entregará -1. En caso de encontrarlo, entrega la dirección donde se encuentra el byte. formato: direccion = ZXAMFindByte( direccion spectrum , byte_a_buscar ) ------------------------------------------------------------------------------- ZXAMRun: Arranca la emulación (simple, ¿no?). formato: ZXAMRun() ------------------------------------------------------------------------------- ZXAMQuit: Provoca la salida del emulador (como cerrar la ventana del emulador). formato: ZXAMQuit() ------------------------------------------------------------------------------- ZXAMppLoadFile: Carga un fichero a través de la powerpacker.library y lo entrega descomprimido en forma de cadena. Si el fichero no estaba comprimido, se cargará igual. formato: bloque = ZXAMppLoadFile( path_y_nombre ) ------------------------------------------------------------------------------- ZXAMppSaveFile: Salva un bloque de bytes a disco, comprimiéndolo con la powerpacker.library. En caso de no querer comprimir el fichero, usar los comandos del ARexx para acceso a ficheros. formato: ZXAMppSaveFile( path_y_nombre , bloque ) ------------------------------------------------------------------------------- ZXAMLoadRequester: Abre el requester de LOAD del emulador. El título es para colocar en la parte superior del requester. El path (opcional) fija en que directorio debe abrirse el requester. En caso de no entregar path se usará el último que se usó con el requester. Si 'path_y_nombre' está vacio significa que se ha pulsado el CANCEL. formato: path_y_nombre = ZXAMLoadRequester( titulo , [path] ) ------------------------------------------------------------------------------- ZXAMSaveRequester: Abre el requester de SAVE del emulador. El título es para colocar en la parte superior del requester. El path (opcional) fija en que directorio debe abrirse el requester. En caso de no entregar path se usará el último que se usó con el requester. Si 'nombre_y_path' está vacio significa que se ha pulsado el CANCEL. formato: path_y_nombre = ZXAMSaveRequester( titulo , [path] ) ------------------------------------------------------------------------------- ZXAMNameFormat: Coloca las cadenas entregadas en las casillas 'Loaded File' y 'Format' de la ventana del emulador. formato: ZXAMNameFormat( nombre , formato ) ------------------------------------------------------------------------------- ZXAMActName: Entrega el nombre contenido en la casilla 'Loaded file'. Si no hay nombre, entregará una cadena vacia. formato: nombre = ZXAMActName() ------------------------------------------------------------------------------- ZXAMActLoadPath: Entrega el último path utilizado en el requester de LOAD. formato: path = ZXAMActLoadPath() ------------------------------------------------------------------------------- ZXAMActSavePath: Entrega el último path utilizado en el requester de SAVE. formato: path = ZXAMActSavePath() ------------------------------------------------------------------------------- ZXAMActFormat: Entrega el nombre de formato contenido en la casilla 'Format'. Si no hay formato, entregará una cadena vacía. formato: formato = ZXAMActFormat() ------------------------------------------------------------------------------- ZXAMActSaveFormat: Entrega el nombre del actual formato seleccionado para save. Puede ser PC, MIRAGE, PC_PP y MIRAGE_PP (los dos últimos son los comprimidos con powerpacker.library). formato: formato = ZXAMActSaveFormat() ------------------------------------------------------------------------------- ZXAMProgVersion: Entrega la versión interna del programa. En el caso de la versión 1.5, entrega la versión interna '39.16'. Sirve por si se quiere usar una función ARexx que solo está presente a partir de cierta versión del emulador (para saber la versión a la que aparece uns función, mira la HISTORIA al final de este DOC). formato: version = ZXAMProgVersion() ------------------------------------------------------------------------------- ZXAMSaveFormat: Selecciona un formato para SAVE. Puede ser PC, MIRAGE, PC_PP o MIRAGE_PP. formato: ZXAMSaveFormat( nombreformato ) ------------------------------------------------------------------------------- ZXAMParseLoaded: Coge el bloque entregado e intenta reconocerlo como snapshot. Si es de formato conocido (PC, MIRAGE, Z80 o KGB, SIN comprimir) colocará los registros y la memoria a los valores de acuerdo al snapshot. A la salida entrega el nombre del formato del bloque (PC, MIRAGE, Z80 o KGB). Si no ha podido reconocer el formato no modificará nada (ni registros ni memoria) y entregará una cadena vacia como nombre de formato. formato: formato = ZXAMParseLoaded( bloque ) ------------------------------------------------------------------------------- ZXAMParseToSave: Entrega la memoria y los registros del Spectrum colocados según el formato seleccionado para SAVE (SIN comprimir). formato: bloque = ZXAMParseToSave() ------------------------------------------------------------------------------- ZXAMJoinPathName: Une el path y el nombre entregados. formato: nombrecompleto = ZXAMJoinPathName( path , nombre ) ------------------------------------------------------------------------------- ZXAMGetScr: Entrega la pantalla actual del Spectrum en formato de 4 bitplanos entrelazados, listo para grabar en una estructura IFF ILBM. formato: bloque = ZXAMGetScr() ------------------------------------------------------------------------------- ZXAMClearNameFormat: Borra las casillas 'Loaded file' y 'Format'. formato: ZXAMClearNameFormat() ------------------------------------------------------------------------------- ZXAMLoadPath: Modifica el path para requester de LOAD sin abrirlo. formato: ZXAMLoadPath( path ) ------------------------------------------------------------------------------- ZXAMSavePath: Modifica el path para requester de SAVE sin abrirlo. formato: ZXAMSavePath( path ) ------------------------------------------------------------------------------- ZXAMFilePart: Entrega el nombre del fichero de un path completo. formato: nombre = ZXAMFilePart( path_y_nombre ) ------------------------------------------------------------------------------- ZXAMPathPart: Entrega el path (sin el nombre del fichero) de un path completo. formato: path = ZXAMPathPart( path_y_nombre ) ------------------------------------------------------------------------------- ZXAMPreRun: Modifica la linea de comandos PRERUN. formato: ZXAMPreRun( linea_de_comandos ) ------------------------------------------------------------------------------- ZXAMActPreRun: Entrega la actual linea de comandos PRERUN. formato: linea_de_comandos = ZXAMActPreRun() ------------------------------------------------------------------------------- ZXAMPostRun: Modifica la linea de comandos POSTRUN. formato: ZXAMPostRun( linea_de_comandos ) ------------------------------------------------------------------------------- ZXAMActPostRun: Entrega la actual linea de comandos POSTRUN. formato: linea_de_comandos = ZXAMActPostRun() ------------------------------------------------------------------------------- ZXAMPattern: Modifica el pattern para los requesters de ficheros. formato: ZXAMPattern( pattern ) ------------------------------------------------------------------------------- ZXAMActPattern: Entrega el pattern actual para los requesters de ficheros. formato: pattern = ZXAMActPattern() ------------------------------------------------------------------------------- ZXAMBASICToken: Entrega el token expandido correspondiente al caracter entregado, o sea, traduce el caracter según la tabla de caracteres y palabras claves (tokens) del Spectrum. Por ejemplo ZXAMBASICToken('ff'x) entregará 'COPY'. Todos los caracteres del 0 al 255 son traducidos. formato: cadena = ZXAMBASICToken( caracter ) ------------------------------------------------------------------------------- ZXAMReadAbort: Entrega un 0 o un 1, indicando si se ha pulsado el gadget 'Abort ARexx'. formato: pulsado = ZXAMReadAbort() ------------------------------------------------------------------------------- ZXAMClearAbort: Borra (a 0) el indicador de que se ha pulsado 'Abort ARexx'. formato: ZXAMClearAbort() ------------------------------------------------------------------------------- ZXAMNoReload: Desactiva el gadget "Reload". Esto debe hacerse cuando hemos dejado modificada la caja 'Loaded File', indicando asi que al pulsar 'Reload' no se cargará lo que aparece en dicha caja. formato: ZXAMNoReload() ------------------------------------------------------------------------------- ZXAMEnableAbort: Activa el gadget 'Abort ARexx'. Esto debe hacerse si quieres leer el gadget desde el script (al arrancar el script el gadget está desactivado por defecto). formato: ZXAMEnableAbort() ------------------------------------------------------------------------------- ZXAMDisableAbort: Desactiva el gadget 'Abort ARexx'. Si no vas a leer el gadget debes desactivarlo, para evitar que el usuario intente interrumpir el script inutilmente. formato: ZXAMDisableAbort() ------------------------------------------------------------------------------- ZXAMDisassemble: Desensambla la instrucción de la dirección dada, entregando a la salida una cadena con el formato: - 1 caracter ASCII que indica el numero de bytes que ocupa la instrucción (para incrementar la dirección entregada y saber así la dirección de la siguiente). Este caracter debe ser eliminado de la cadena antes de imprimirla en pantalla o impresora. - el resto de la cadena es un desensamblado en en habitual formato 'dirección+codigo objeto+mnemonico'. En el caso de que la instrucción desensamblada fuera un salto relativo (JR, DJNZ, etc...) se añadirá al final de la linea un comentario que indicará la dirección destino del salto. Las instrucciones ilegales se representarán como '---'. El parametro opcional "formato" determina el formato en que se imprimen las direcciones/datos. Si es 'H' se imprimirán en hexadecimal, y si es 'D' se imprimirán en decimal. Si no se entrega este parámetro, se imprimirá en hexadecimal formato: ZXAMDisassemble( direccion , [formato] ) ------------------------------------------------------------------------------- ZXAMLoadMode: Indica el modo del parche LOAD (o sea, controla el menu LOAD MODE). Se le entrega el modo deseado ('TAPE' o 'DISK'). formato: ZXAMLoadMode( modo ) ------------------------------------------------------------------------------- ZXAMSaveMode: Indica el modo del parche SAVE (o sea, controla el menu SAVE MODE). Se le entrega el modo deseado ('TAPE', 'DISK' o 'DISK_PP'). formato: ZXAMSaveMode( modo ) ------------------------------------------------------------------------------- ZXAMActLoadMode: Indica el modo en el que está actualmente el parche LOAD (o sea, muestra el estado del menu LOAD MODE). El resultado es una cadena ('TAPE' o 'DISK'). formato: modo = ZXAMActLoadMode() ------------------------------------------------------------------------------- ZXAMActSaveMode: Indica el modo en el que está actualmente el parche SAVE (o sea, muestra el estado del menu SAVE MODE). El resultado es una cadena ('TAPE', 'DISK' o 'DISK_PP'). formato: modo = ZXAMActSaveMode() ------------------------------------------------------------------------------- ZXAMAbout: Muestra el requester de 'About...' del emulador. formato: ZXAMAbout() ------------------------------------------------------------------------------- ZXAMFindBlock: Busca un bloque de bytes el la memoria del Spectrum. El primer argumento es la dirección donde empezar la búsqueda, y el segundo es el conjunto de bytes (en forma de cadena) a buscar. Esto significa que para buscar 'HOLA' debemos hacer ZXAMFindBlock(0,'HOLA'), y para buscar los bytes 0F 45 7B haremos ZXAMFindBlock(0,'0F457B'x). En caso de que el numero hexadecimal esté en una variable, usar x2c(variable) en el segundo argumento, para que el ARexx convierta la cadena hexadecimal en los bytes correspondientes. El resultado es la dirección donde esa secuencia de bytes ha sido encontrada, o -1 si no lo ha sido. formato: dirección = ZXAMFindBlock( dirección , bloque_a_buscar ) ------------------------------------------------------------------------------- ZXAMDoChecksum: Hace una suma de comprobación como la que hace la rutina SAVE de la ROM, o sea, un XOR (OR exclusiva) de todos los bytes del bloque de datos. Los parámetros son la dirección de inicio del bloque y el numero de bytes que lo componen. Por ejemplo, ZXAMDoChecksum(0,16384) entregará el resultado de hacer XOR de todos los bytes de la ROM. formato: resultado = ZXAMDoChecksum( dirección , numero_bytes ) ------------------------------------------------------------------------------- ZXAMBreakPoint: Coloca un breakpoint (punto de ruptura) en la dirección dada de la memoria del Spectrum. Si durante la ejecución se llega al breakpoint el emulador sale al workbench (como si se pulsase la tecla 'HELP'). En memoria solo puede haber UN breakpoint, por lo que al poner uno se elimina el anterior. Si la dirección es 0 se borra el breakpoint anterior sin colocar ninguno nuevo. El breakpoint es una instrucción, por lo que si el programa modifica esa parte del código desaparece el breakpoint. El breakpoint solo "sobrevive" a una entrada al emulador, o sea, tan pronto como se pulse 'HELP' para salir de la emulación, éste desaparecerá (las salidas provocadas por load/save de disco no afectan al breakpoint). formato: ZXAMBreakPoint( dirección ) ------------------------------------------------------------------------------- ZXAMTrace: Ejecuta la instrucción a la que apunta PC (sin desconectar la multitarea). Una vez ejecutada la instrucción la función devuelve el desensamblado de la instrucción ejecutada (igual que ZXAMDisassemble()). El 'formato' puede ser 'd' o 'h', indicando si el desensamblado debe ser decimal o hexadecimal (como el segundo parámetro de ZXAMDisassemble()). El 'formato' es opcional, siendo hexadecimal por defecto. Al contrario que para arrancar el emulador, ni las CIAs ni los canales de audio necesitan ser alojados para ejecutar código paso-a-paso. formato: desen = ZXAMTrace( [formato] ) ------------------------------------------------------------------------------- ZXAMDoInt: Efectua una interrupción (como si hubiese llegado la señal INT al microprocesador Z80), o sea, mete PC en la pila del Z80, y le da a PC el valor adecuado al modo de interrupción actual (en IM1 le da el valor $38, y en IM2 mete el vector de la tabla apuntada por I). Si las interrupciones no están permitidas, la función no hace nada. formato: ZXAMDoInt() ------------------------------------------------------------------------------- ZXAMBlockOfRegs: Entrega un bloque de 27 bytes que contiene todos los registros y estados internos del procesador Z80, en el siguiente orden: Pos Tamaño Contenido 0 1 A 1 1 F 2 2 BC 4 2 DE 6 2 HL 8 1 A' 9 1 F' 10 2 BC' 12 2 DE' 14 2 HL' 16 2 IX 18 2 IY 20 2 SP 22 2 PC 24 1 Estado Interrupción (0=no permitidas / 1=permitidas) 25 1 Modo de Interrupción (0, 1 o 2) 26 1 Color del Borde (0 a 7) Los registros dobles están en formato 68000, o sea, con el byte más significativo PRIMERO. formato: bloque = ZXAMBlockOfRegs() ------------------------------------------------------------------------------- REGISTROS: los registros accesibles por ZXAMGetReg y ZXAMSetReg son los habituales del Z80, en el formato: -registros de 8 bits: su nombre directo, incluyendo las mitades de los registros de 16 bits no divisibles, o sea, SPH y SPL son las dos mitades del registro SP de 16 bits. -registros de 16 bits: su nombre directo, como HL y PC. AF no está implementado, o sea que hay que leer A y F por separado. -registros de 16 bits invertidos: si se invierte el nombre de un registro de 16 bits (por ejemplo LH o XI) la lectura/escritura se realiza intercambiando los bytes alto y bajo del registro. En el script 'LoadSnap.zxam' verás un ejemplo de para que sirve. -"registros" especiales: son INT : estado de las interrupciones (0=OFF, 1=ON) IM : modo de interrupción (0, 1 o 2) BOR : color actual del borde (0 a 7) en todos los casos se le añade un '2' al final del nombre para acceder a los registros del juego alternativo, o sea, para acceder a hl' y a a' escribiremos HL2 y A2. Los nombres son independientes de mayúsculas/minúsculas. Todos los casos admiten lectura y escritura. [0;1mCUESTIONES TECNICAS[0m Este programa ha sido escrito en ensamblador desde la primera linea de código a las 17750 (!!!!) actuales (151023 al expandir las MACROs). En mi Amiga 1200 con disco duro y 68030/28MHz el emulador tarda 51 seg en ensamblarse (antes eran 3 min 50 seg cuando no tenia disco duro, o 4 min 53 seg la última versión que ensamblé sobre el 500 Plus). La verdad es que se me ha ido un poco la mano... Este es el tercer programa "completo" que hago en ensamblador. Empecé a programarlo sobre un Amiga 500 Plus con 2 Megas de RAM, 3 disqueteras y el ensamblador Devpac 3.02. En cuanto he podido comprarme un Amiga 1200 he covertido el emulador a código 68020 puro y chips AGA. Lo empecé para aprender sobre todo en cuanto a código específico 68020, para explorar las posibilidades y ventajas de programar en codigo especial para este procesador. Era además un capricho de programador compulsivo (es que soy adicto a la programación). Cuando solo tenia el 500Plus programaba condicionalmente en código 68000 y 68020 al mismo tiempo y lo probaba en el Amiga 4000/030 de un amigo. Aprovechado mi reciente adquisición del Amiga 1200 también he investigado sobre las posibilidades de los chips AGA (que son muchas) y la forma de utilizarlos. Ahora al fin tengo un equipo en condiciones (A1200 420Mb HD, 68030/28MHz y 6 Mb de memoria). Ahora programar es un gustazo!! [0;1mPRE-HISTORIA[0m La primera versión (en blanco y negro, arrancable desde SHELL y con el ManicMiner integrado en el ejecutable) funcionó en 10 dias. A partir de ahí hay acumulados 6 sistemas diferentes de emulación del color del Spectrum (los atributos y la estructura de la pantalla), 4 reestructuraciones del emulador del Z80 y montones de horas buscando errores y apurando la velocidad del procesador. Ninguna de las versiones pre-AGA han sido distribuidas. El emulador no ha sido, ni es, un proyecto de tiempo completo. Mientras desarrollaba el emulador he estado estudiando un curso de sistemas automáticos, he desarrollado otro programa, llamado MPMaster, y he estado practicando mi vagancia habitual ;-) [0;1mHISTORIA[0m Versión Versión interna 1.0 ß 39.00 -Primera versión en circulación. (distribuida como ZXAM Spectrum Emulator AGA 1.0 ß) 1.1 ß 39.01 (ejecutable llamado ZXAM_CuelgueSeguro) -Desactiva filtro de audio al entrar. Lo restaura al salir. -Desactivadas las interrupciones de los Timers. Actualmente solo permanece activada la del teclado. Esto ha mejorado drásticamente el sonido. -Debido a la desactivación de los Timers el emulador se "congela" al cabo de un cierto numero de pulsaciones de tecla (en realidad el que se cuelga es el HANDLER DE TECLADO DEL SISTEMA, ya que se le desborda el buffer). 39.02 (19-ABRIL-94, tras 2 semanas sabáticas) -añadido gadget ZOOM a la ventana del programa -el hadler del teclado me sigue tocando las narices... (no se llegó a distribuir) 1.2 ß 39.03 (26-JUNIO-94, tras 2 meses de exámenes y MPMaster) -¡Al fin! Arreglado el problema con el teclado. El emulador ya no se cuelga por culpa del desborde del buffer del teclado. -Ahora, si pulsamos Caps Lock dentro del spectrum, al salir al sistema, éste es informado correctamente del estado de mayúsculas del teclado. Antes, al no recibir bién la señal, escribia minúsculas aunque Caps Lock estuviese iluminado. -Disponibles versiones FULL (completa) y FAST (rápida) para usar en Amiga 4000 y 1200 respectivamente. La versión FAST es un 10% más rápida que la FULL, aproximadamente, aunque se aprecia en algunos programas mejor que en otros. Esto se ha conseguido eliminando algunos detalles de la emulación. 39.04 -El emulador se "despega" de la ventana del SHELL, dejándola libre por si quieres usarla, o cerrarla. -Ahora se leen las opciones del icono incluso si arrancas el emulador desde SHELL. 39.05 -Eliminado el problema con el audio. Ahora el sonido del spectrum suena perfectamente aunque antes de arrancarlo hubiera algún tipo de player (como el Delitracker) en marcha. A la salida el tracker seguirá donde estaba (al menos, con los players que yo tengo...). 39.06 -Realizadas algunas optimizaciones preparatorias para la implementación de LOAD y SAVE de cinta. -Ahora alojamos el Timer-B de la CIA-B para las temporizaciones del emulador, en preparación para el estabilizador de audio. (distribuida como ZXAM Spectrum Emulator AGA 1.2 ß) 1.3 ß 39.07 (7-JULIO-94) -Primer intento de parchear la ROM para cargar. La carga puede realizarse tanto en B/N como en color, incluso sin la presencia de memoria FAST (!). Tampoco es necesario parar las interrupciones del FLASH (!!). La estabilidad de carga parece muy buena, aunque debe probarse en otras configuraciones (68040, 68030/40MHz o 68030/50MHz). Sobre el 1200 y 4000/030 la carga funciona perfectamente. -Sincronizada instrucción OUT. Con esto ya tenemos SAVE en TIEMPO REAL (incluso en color!!), y BEEP en tiempo real. El sonido de algunos juegos ha mejorado extraordinariamente (como el Pheenix). Por otro lado otros juegos se han ralentizado alrededor de un 3% (3 weeks in paradise) debido a que la sincronia supone instrucciones adicionales en la rutina OUT. 39.08 (11-JULIO-94) -¡Borde REAL! Si la velocidad es suficiente se pueden ver los efectos de borde que hacen algunos programas. -Reajustada la correspondencia de colores para BRIGHT 0 y 1. Ahora la proporción de brillo es prácticamente idéntica a la del Spectrum original. -Reajustes del parche de carga. Sigue funcionando igual de bién pero ahora reacciona mejor al BREAK, HELP y ESC. -Al fin le he dado la segunda vuelta al contador de lineas del Devpac. La versión 39.08 consta de 133637 lineas con las macros expandidas. Si sigo así no me bastarán los 2 Megas del A1200 para ensamblarlo... :-) 39.09 (16-JULIO-94) -Arreglado el problema del borde con el parche de la rutina LOAD y con la instrucción OUT. Ahora el borde es "casi" perfecto tanto con LOAD como con SAVE (y OUT). (distribuida como ZXAM Spectrum Emulator AGA 1.3 ß) 1.3b ß 39.10 (23-JULIO-94) -El emulador tiene ahora un "Transfer" integrado para poder pasar a cinta los programas que tenemos en disco (prueba de pulsar F6). Inicialmente incluido para usarlo yo mismo en las comparativas de velocidad entre el 1200 y el +2A. -En el momento de hacer "transfer", el bloque BASIC se graba con el nombre del programa cargado desde disco. -El transfer no usa rutina de carga propia, por lo que puedes cargar los programas en el propio emulador (¡que ilusión! ;-) -La "transfer"-encia se puede interrumpir con la tecla HELP. -El transfer graba en el cargador incluso el color del borde, cosa que los auténticos transfers de Spectrum no hacian. -Al hacer "Save Program" el nombre pasa al gadget "Loaded File", de forma que podemos hacer "Reload" del programa salvado, además de saber el nombre que hemos usado y el formato. -El requester de SAVE conserva un path diferente al de LOAD, facilitando así la conversión de ficheros entre diferentes directorios. -Si no se ha cargado ningún programa, al hacer transfer el programa se graba con el nombre LOADER. 39.11 (31-JULIO-94) -Realizados unos ajustes en la sincronización del emulador. El sonido sigue estando estabilizado, pero ciertos juegos (Manic Miner,...) han recuperado su vieja velocidad ;-D -Arreglado un error en el transfer. Con este error, solo la primera transferencia funcionaba correctamente. La segunda vez el código Z80 del transfer resultaba corrupto. -Arreglado el problema del Kempston con el Panama Joe y el Commando. -El acceso al borde es un poco más rápido. (distribuida como ZXAM Spectrum Emulator AGA 1.3b ß) 1.4 ß 39.12 (2-SEPTIEMBRE-94) -Primeros ensayos de puerto ARexx. Implementadas funciones GetReg, SetReg, Peek, Poke y Putmem. HA FUNCIONADO A LA PRIMERA!!!! 39.13 (10-SEPTIEMBRE-94) -Ahora los menús son tipo NewLook (blancos con letras negras). -Añadidos mas funciones ARexx: DPeek, DPoke, FindByte, y el acceso a los registros Z80 en orientación Z80 y 68000. Posibilidad de recibir comandos y funciones. -Añadido el código para arrancar scripts ARexx desde el emulador. Ahora tengo que modificar la ventana para el botón de ejecutar script ARexx. -Escritos ya algunos scripts de ejemplo. 39.14 (16-SEPTIEMBRE-94) -Añadida la versión interna al About... -Añadida ToolType ROMFILE para cargar ROMs externas. La ROM puede estar comprimida con powerpacker. -El nombre del último programa cargado/grabado aparece en el requester de SAVE, pero con la extensión adecuada al formato. -Añadidas funciones ARexx: Run, Quit, NameFormat, GetMem, ppLoadFile, ppSaveFile, LoadRequester, SaveRequester, ActName, ActLoadPath, ActSavePath y ActFormat. -Modificados los scripts de ejemplo para uso de las rutinas SAVE y LOAD a través de powerpacker. -Añadido el gadget para ejecutar scripts ARexx (de forma un poco chapucerilla....). Abre un requester de ficheros para elegir el script a ejecutar. -Añadida ToolType REXXPATH para indicar el path de los scripts ARexx. La extensión es SIEMPRE '.zxam'. -Ahora al arrancar el programa, éste hace CD al directorio donde está el ejecutable, aunque nos arranquen desde shell con CD en otro directorio. Esto significa que TODOS los paths entregados al emulador son relativos al directorio del ejecutable, o deben contener un path completo. (no distribuida) 1.5 39.15 (28-SEPTIEMBRE-94) -Añadida la posibilidad de grabar los programas comprimidos con la powerpacker.library. -Reorganizados los botones de selección de formato para SAVE. Ahora hay dos botones para cada formato (comprimido y sin comprimir). -Añadida dirección FidoNet al About ;-) -Añadidas funciones ARexx: ProgVersion, ActSaveFormat, SaveFormat, ParseToSave, ParseLoaded, JoinPathName, ClearNameFormat, GetScr, FilePart, PathPart, LoadPath, SavePath, PreRun, ActPreRun, PostRun, ActPostRun, Pattern, ActPattern y BASICToken. -Si hay algún problema inicializando el puerto ARexx, el gadget de ejecución de scripts ARexx queda desactivado. -Añadida la posibilidad de poner un titulo a los requesters de SAVE y LOAD. -Ahora el emulador devuelve correctamente la memoria cuando detecta que falta el WB 3.0+, el 68020+ o los chips AGA. -La ventana es una AppWindow, o sea, puedes tirar dentro los iconos de los ficheros a cargar. Si lo que metes es un cajón o un disco, se abrirá el requester de ficheros en dicho cajón/disco. -Añadidas ToolTypes PRERUN y POSTRUN para correr comandos antes de arrancar la emulación y después de pararla. -Antes de PRERUN se almacena el estado de los cachés, y se recupera al volver, antes de POSTRUN. -El emulador ha dejado de ser BETA. Esto significa que la ventana está completa (o sea, que todo su contenido funciona) y que se puede arrancar sin peligro de cuelgues salvajes ni fuegos artificiales (a mi no se me cuelga desde hace meses). Los defectos de emulación no se incluyen en la consideración de BETA, ya que si no el emulador podria ser BETA eternamente. Esto NO significa que renuncie a mejorar la emulación (¡NI MUCHO MENOS!) ;-) 39.16 (12-OCTUBRE-94) -Añadidas funciones ARexx: ClearAbort, ReadAbort y NoReload. -Añadido el gadget 'Abort ARexx' para poder parar los scripts ARexx, aunque es responsabilidad del script el leer dicho gadget. 39.17 (27-OCTUBRE-94) -Modificadas algunas instrucciones que acceden al flag P/V. -Creada una versión OCS/ECS del emulador. Esta versión no tiene FLASH y la emulación de color es un poco más lenta que la AGA. Todas las demás posibilidades del emulador AGA están incorporadas al esta versión (ARexx, AppWindow, carga de cinta, etc...) (distribuida como ZXAM Spectrum Emulator 1.5) 1.6 39.18 (14-NOVIEMBRE-94) -Ahora el emulador aloja legalmente el canal 0 de audio antes de entrar en la emulación, y lo devuelve al salir. En caso de no poder alojarlo no empieza la emulación y muestra un requester. 39.19 (6-DICIEMBRE-94) -Integrado un desensamblador en el emulador. Hay un nuevo comando ARexx (ZXAMDisassemble(dirección)) que desensambla la instrucción de la dirección indicada. -Arreglado el problema con el teclado de algunos juegos de DINAMIC (debido a sus tecnicas chapuceras de programación). -Añadido menu para activar/desactivar la sincronización del audio con las CIAs. -Añadida tooltype CIASYNC. -Añadido menu para seleccionar el modo de SAVE de la rutina de la ROM (Cinta/Disco/Disco comprimido). Al salvar un bloque (ya sea cabecera o datos) salimos al sistema con un requester de ficheros, que contendrá ya la extensión adecuada. Si pulsamos CANCEL se realiza un BREAK en el emulador. -Añadido menu para seleccionar el modo de LOAD (Cinta/Disco) -Arreglado un error en la gestión de los flags del Z80 al modificarlos desde ARexx. -Mejorada la lectura de la CIA. -Ahora el emulador aloja cualquier timer de las CIAs (ya no tiene que ser específicamente el timer-b de la cia-b). -El timer de la CIA se aloja durante la emulación. -Arreglado problema con el flash en sistemas con caché de datos (030 y 040). -Añadida posibilidad de cargar snapshots en formato Z80. 39.20 (22-DICIEMBRE-94) -Arreglado el problema con scripts arexx situados en un path que contenga espacios. Aún así, el nombre del script no puede contener espacios (es una limitación del ARexx). -Añadidas tooltypes LOADMODE y SAVEMODE para controlar los modos de carga/grabación. -Arreglado un problema al substituir la extensión en el nombre de un fichero al hacer 'save program'. Cuando el nombre contenia varios puntos, se ponia la extensión después del primero, cuando debia ser después del último. -Se pueden cargar juegos con iconos cuya default tool es el emulador, o también por multiselección -Añadido al comando Disassemble la posibilidad de mostrar los datos y direcciones en decimal o hexadecimal -Ahora al desensamblar una instrucción de salto relativo se imprime como comentario la dirección absoluta a donde va dicho salto. -El transfer ya siempre va a cinta (arreglado el bug por el cual el trasfer era afectado por el menu "Save mode"). -Añadida posibilidad de cargar snapshots Z80 de formato moderno (2.01). Anteriormente solo se podian cargar los de formato antiguo (1.45). -Modificada funcion ARexx ParseLoaded() para que reconozca también el formato Z80. -Eliminado el menu que permite activar/desactivar la sincronización del audio con las CIAs. Eliminada también la ToolType CIASYNC. -Arreglado un bug inofensivo en la rutina de grabar el formato PC_PP. -Ahora el emulador aloja TODOS los canales de audio, para una proxima emulación del chip AY-3-8912 del +2/+2A/+3. -El ejecutable ya no está comprimido con powerpacker por que parece que la rutina descompresora causaba gurús algunas veces. (distribuida como ZXAM Spectrum Emulator 1.6) 1.6b 39.21 (19-ENERO-94) -Arreglado un error en la carga de snapshots en formato Z80. En muchos casos el emulador no reconocia correctamente los programas en formato Z80 (versión 1.45) comprimidos. Esto es debido a información erronea en el manual del "Z80" 1.45 y a la falta de programas en formato Z80 para probar. -Añadida la posibilidad de cargar (aunque no grabar) programas en formato KGB. -Modificadas algunas instrucciones para que incrementen correctamente el registro R. -Ligeras mejoras en la emulación de los flags del Z80. -Añadido script ARexx para desensamblar, buscar pokes, y trastear por los programas, como si de un monitor se tratara (Hecho por Leo Cocaña. ¡Gracias Leo! :-) -Arreglados dos errores en el desensamblador (en las instrucciones 'ld hl,(nn)' y 'ld (nn),de'). -Añadidas funciones ARexx LoadMode(), SaveMode(), ActLoadMode() y ActSaveMode(), para controlar así desde ARexx el menu de opciones LOAD/SAVE. -Añadida función ARexx About() -Modificada la función ARexx ParseLoaded() para que también reconozca los snapshots en formato KGB. -Ahora 'Reload' funciona correctamente tras 'Save program'. -Tras 'Reset & Run' ya no funciona 'Reload' desde teclado. -integrada una pausa de 1 segundo al final de la rutina SAVE de la ROM, para programas que salvan bloques demasiado juntos (como el ensamblador GENS). -Añadidas funciones ARexx FindBlock() y DoChecksum(). -Añadidas funciones ARexx BreakPoint(), Trace(), DoInt() y BlockOfRegs(). Estas funciones permiten ejecutar código Z80 paso a paso, y poner puntos de ruptura. -Modificada la función ARexx GetReg(). Ahora tiene un segundo parámetro (opcional) con el que se puede indicar el formato del resultado (decimal o hexadecimal). -Ahora cuando hay en marcha un script ARexx ya no se acumulan los eventos 'cerrar ventana', y los menús son desactivados. -Arreglado un error en 'Reload' tras grabar un programa en formato PC_PP. (distribuida como ZXAM Spectrum Emulator 1.6b) [0;1mMEJORAS A REALIZAR[0m En el futuro las versiones disponibles serán: - Versión rápida: con cargador de cinta externo, parcheando la ROM como el Spectrum Emulator v1.7, pensada para Amiga 1200. En esta versión dejan de emularse cosas como el registro R, el BCD, y algunas temporizaciones se hacen menos precisas, para sacar un poco más de velocidad a costa de una emulación menos "refinada". Esta versión servirá solo PARA JUGAR. - Versión completa: podrá cargar en tiempo real, con lo que cargará correctamente programas protegidos de cualquier tipo (como un Spectrum real), en ordenadores más potentes (Amiga 4000). En esta versión se emula todo lo posible (registro R, cálculos BCD, etc...). Incorporará un parche opcional para cargar de cinta en sistemas sin la potencia suficiente para cargar en tiempo real. Puede que haya posibilidad de carga REAL incluso en un 1200 con memoria FAST de 32 bits, pero no puedo comprobarlo hasta que no consiga un poco de dicha memoria para el mio. [0;1mAGRADECIMIENTOS[0m Mis más sinceros agradecimientos para: - Fco Javier Cocaña Galán, Leonardo Cocaña Galán y Juan A. Estela Valín por su amistad, y por sus constantes sugerencias (y feroces críticas). - Commodore-Amiga Inc por crear el mejor ordenador del mundo. - Motorola por sus excelentes microprocesadores, fáciles de programar y extremadamente flexibles. - Nico François por crear las fantásticas librerias reqtools.library y powerpacker.library. - Jan van den Baard por el utilísimo GadToolsBox. - IBM y Atari por crear unos ordenadores tan malos y facilitar así mi elección por el Amiga (muchiiisimas gracias). - Miguel Barnosi, Sysop de TANIT-BBS, por haber distribuido el emulador por otras BBS y por hacer de "puente" entre la FidoNET y yo, y por iniciarme en lo de Fido. - Alberto Ordoñez Tellez, Raúl Ureña Sánchez, Arturo Rubio Pavón, Javier López Cosialls y Sergi Martinez Colldeforn por sus animos y sus sugerencias. - Andrew Pointon (Inglaterra) por mandarme unos snapshots en formato Z80 (sin los cuales no podia implementar el formato) y ficheros en formato .TAP (que tampoco tenia). - Flávio Massao Matsumoto (Brasil) por mandarme el "ZX Spectrum FAQ" de Internet. Sin él, no habria podido añadir el formato KGB. - Jordy Mejias por pasarme el disco del KBG, que yo habia borrado hacia tiempo. [0;1mPARA CONTACTAR[0m Te agradeceria que me enviases toda información que me pueda ser útil para ampliar la potencia del emulador, como por ejemplo, información sobre otros formatos de fichero. En el caso de querer informar sobre algún error o incompatibilidad lo mejor es que me mandes el/los programas de Spectrum que producen dicho problema, junto con toda la información posible sobre el equipo que usas (procesador, sistema operativo, tamaño y tipo de memoria, etc...). También me gustaria que me informases de la velocidad del emulador en tu ordenador. Yo he podido probarlo en un 4000/030 con FAST (corre más que un Spectrum real, y el SAVE va a velocidad de TURBO) y en mi 1200 sin FAST (snif). Para informarme puedes cronometrar, por ejemplo, lo que tarda un RESET, un bucle largo de BASIC (por favor, incluye el listado del bucle para que yo pueda ejecutarlo), o cualquier otra cosa que yo pueda comparar con el 1200 o con el Spectrum real (aún conservo un +2A, un Plus, y un +3 que está cadaver [RIP]). Prueba también el programa _SpeedTest_.SP que está junto al emulador. Para enviar sugerencias, informar de errores, intercambiar información, etc, contacta conmigo en esta dirección: Antonio J. Pomar Rosselló C/ Alférez Cerdá nº 13-bajos Palma de Mallorca 07014 Baleares (España) o, si tienes modem, puedes contactar conmigo a través de TANIT BBS-IBIZA (971-392829). Deja un mensaje a nombre de TONIACE. A través de FidoNet puedes mandarme mensajes a: Toni Pomar (2:343/119.80). Por AmigaNet también puedes mandarme mensajes a: Toni Pomar (39:190/1.80). En InterNet mi dirección es: tpomar@penedes.mazanet.encomix.com Palma de Mallorca 14-Enero-1995 [0m[1 p